home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 5 / Amiga Tools 5.iso / grafik / converter / limbo4.0 / src / 2d / mapop.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-16  |  17.8 KB  |  541 lines
  1. #include "includes.h"
  2.  
  3. /**************************************|****************************************
  4. Routine   : Map2BitMap
  5. Input  par: BitMap *SrcImg    (Pointer to the source image to copy.)
  6.             BitMap *DstImg    (Pointer to the destination image.)
  7.             int XStart        (The x position in the source image to start
  8.                                copying from.)
  9.             int YStart        (The y position in the source image to start
  10.                                copying from.)
  11. Output par: None
  12. Function  : Copies a part of a BitMap to a new BitMap.
  13. ***************************************|***************************************/
  14.  
  15.  void Map2BitMap(BitMap *SrcImg,BitMap *DstImg,int XStart,int YStart)
  16.   {
  17.    register unsigned int x,y;
  18.    const unsigned int Sizex=DstImg->XSize;
  19.    const unsigned int Sizey=DstImg->YSize;
  20.  
  21.    if (SrcImg->ImgType!=DstImg->ImgType) 
  22.    ErrorHandler(WRONG_FORMAT,"Images not of the same type");
  23.    for(x=0;x<Sizex;x++)    
  24.    for(y=0;y<Sizey;y++) DstImg->Map[x][y]=SrcImg->Map[XStart+x][YStart+y];
  25.   }
  26.  
  27. /**************************************|****************************************
  28. Routine   : BitMap2Map
  29. Input  par: BitMap *SrcImg      (Pointer to the bitmap to copy.)
  30.             BitMap *DstImg      (Pointer to the image to copy the source image
  31.                                  into.)
  32.             int XStart,YStart   (The x and y location in the destination image
  33.                                  to copy the source image into.)
  34. Output par: None
  35. Function  : Copies a the source bitmap into the specified location of the
  36.             destination bitmap.
  37. ***************************************|***************************************/
  38.  
  39.  void BitMap2Map(BitMap *SrcImg,BitMap *DstImg,int XStart,int YStart)
  40.   {
  41.    register unsigned int x,y;
  42.    const unsigned int Sizex=SrcImg->XSize;
  43.    const unsigned int Sizey=SrcImg->YSize;
  44.  
  45.    if (SrcImg->ImgType!=DstImg->ImgType) 
  46.    ErrorHandler(WRONG_FORMAT,"Images not of the same type");
  47.    for(x=0;x<Sizex;x++)     
  48.    for(y=0;y<Sizey;y++) DstImg->Map[XStart+x][YStart+y]=SrcImg->Map[x][y];
  49.   }
  50.  
  51. /**************************************|****************************************
  52. Routine   : Map3D2BitMap3D
  53. Input  par: BitMap3D *SrcImg (Pointer to the source image to copy.)
  54.             BitMap3D *DstImg (Pointer to the destination image.)
  55.             int XStart       (The x position in the source image to start
  56.                               copying from.)
  57.             int YStart       (The y position in the source image to start
  58.                               copying from.)
  59. Output par: None
  60. Function  : Copies a part of a BitMap3D to a new BitMap3D. Analog to Map2BitMap
  61. ***************************************|***************************************/
  62.  
  63.  void Map3D2BitMap3D(BitMap3D *SrcImg,BitMap3D *DstImg,int XStart,int YStart,int ZStart)
  64.   {
  65.    register unsigned int x,y,z;
  66.    const unsigned int Sizex=DstImg->XSize;
  67.    const unsigned int Sizey=DstImg->YSize;
  68.    const unsigned int Sizez=DstImg->ZSize;
  69.  
  70.    if (SrcImg->ImgType!=DstImg->ImgType) 
  71.    ErrorHandler(WRONG_FORMAT,"Images not of the same type");
  72.    for(x=0;x<Sizex;x++)    
  73.    for(y=0;y<Sizey;y++)
  74.    for(z=0;z<Sizez;z++)
  75.    DstImg->Map[x][y][z]=SrcImg->Map[XStart+x][YStart+y][ZStart+z];
  76.   }
  77.  
  78. /**************************************|****************************************
  79. Routine   : CopyBitMap
  80. Input  par: BitMap *SrcImg (Pointer to the source image.)
  81.             BitMap *DstImg (Pointer to the destination image.)
  82. Output par: None
  83. Function  : Copies a BitMap struct.
  84. ***************************************|***************************************/
  85.  
  86.  void CopyBitMap(BitMap *SrcImg,BitMap *DstImg)
  87.   {
  88.    register unsigned int x,y;
  89.    if (SrcImg->ImgType!=DstImg->ImgType)   ErrorHandler(WRONG_FORMAT,"Images not of the same type");
  90.    for(x=0;x<DstImg->XSize;x++)    
  91.     {
  92.      for(y=0;y<DstImg->YSize;y++) DstImg->Map[x][y]=SrcImg->Map[x][y];
  93.     }
  94.   }
  95.  
  96.  
  97. /**************************************|****************************************
  98. Routine   : BitMap3D2Map3D
  99. Input  par: BitMap3D *SrcImg    (Pointer to the bitmap to copy.)
  100.             BitMap3D *DstImg    (Pointer to the image to copy the source image
  101.                                  into.)
  102.             int XStart,YStart   (The x and y location in the destination image
  103.                                  to copy the source image into.)
  104. Output par: None
  105. Function  : Copies a the source 3D bitmap into the specified location of the
  106.             destination bitmap. Analog to BitMap2Map
  107. ***************************************|***************************************/
  108.  
  109.  void BitMap3D2Map3D(BitMap3D *SrcImg,BitMap3D *DstImg,int XStart,int YStart,int ZStart)
  110.   {
  111.    register unsigned int x,y,z;
  112.    const unsigned int Sizex=SrcImg->XSize;
  113.    const unsigned int Sizey=SrcImg->YSize;
  114.    const unsigned int Sizez=SrcImg->ZSize;
  115.  
  116.    if (SrcImg->ImgType!=DstImg->ImgType) 
  117.    ErrorHandler(WRONG_FORMAT,"Images not of the same type");
  118.  
  119.    for(x=0;x<Sizex;x++)     
  120.    for(y=0;y<Sizey;y++)
  121.    for(z=0;z<Sizez;z++) 
  122.    DstImg->Map[XStart+x][YStart+y][ZStart+z]=SrcImg->Map[x][y][z];
  123.   }
  124.  
  125. /**************************************|****************************************
  126. Routine   : CopyBitMap3D
  127. Input  par: BitMap3D *SrcImg (source image to copy)
  128.             BitMap3D *DstImg (dest to copy to)
  129. Output par: none
  130. Function  : Copies a 3d bitmap to another 3d bitmap.
  131. ***************************************|***************************************/
  132.  
  133.  void CopyBitMap3D(BitMap3D *SrcImg,BitMap3D *DstImg)
  134.   {
  135.    register unsigned int x,y,z;
  136.    const unsigned int Sizex=DstImg->XSize;
  137.    const unsigned int Sizey=DstImg->YSize;
  138.    const unsigned int Sizez=DstImg->ZSize;
  139.  
  140.    if (SrcImg->ImgType!=DstImg->ImgType) 
  141.    ErrorHandler(WRONG_FORMAT,"Images not of the same type");
  142.  
  143.    for(x=0;x<Sizex;x++)    
  144.    for(y=0;y<Sizey;y++)
  145.    for(z=0;z<Sizez;z++) DstImg->Map[x][y][z]=SrcImg->Map[x][y][z];
  146.   }
  147.  
  148. /**************************************|****************************************
  149. Routine   : Frame2BitMap
  150. Input  par: BitMap3D *SrcImg (3d bitmap from where a frame must be extracted)
  151.             int z            (the number of the frame to be extracted)
  152.             BitMap *DstImg   (2d bitmap to copy to)
  153. Output par: none
  154. Function  : Copies a single frame of a 3d image to a 2d image.
  155. ***************************************|***************************************/
  156.  
  157.  void Frame2BitMap(BitMap3D *SrcImg,int z,BitMap *DstImg)
  158.   {
  159.    register unsigned int x,y;
  160.    if (SrcImg->ImgType!=DstImg->ImgType) 
  161.    ErrorHandler(WRONG_FORMAT,"Images not of the same type");
  162.    for(x=0;x<DstImg->XSize;x++)    
  163.    for(y=0;y<DstImg->YSize;y++) DstImg->Map[x][y]=SrcImg->Map[x][y][z];
  164.   }
  165.  
  166. /**************************************|****************************************
  167. Routine   : BitMap2Frame
  168. Input  par: BitMap *SrcImg   (2d bitmap frame)
  169.             BitMap3D *DstImg (3d bitmap image)
  170.             int z            (frame number of the 3d sequence)
  171. Output par: none
  172. Function  : Copies a 2d frame into a 3d bitmap.
  173. ***************************************|***************************************/
  174.  
  175.  void BitMap2Frame(BitMap *SrcImg,BitMap3D *DstImg,int z)
  176.   {
  177.    register unsigned int x,y;
  178.    if (SrcImg->ImgType!=DstImg->ImgType) 
  179.    ErrorHandler(WRONG_FORMAT,"Images not of the same type");
  180.    for(x=0;x<DstImg->XSize;x++)    
  181.    for(y=0;y<DstImg->YSize;y++) DstImg->Map[x][y][z]=SrcImg->Map[x][y];
  182.   }
  183.  
  184. /**************************************|****************************************
  185. Routine   : T_CScaleAndLShift3D
  186. Input  par: BitMap3D *SrcImg (3d bitmap image to be shifted and scaled)
  187.             float Scale      (contrast scale parameter , i.e. alpha)
  188.             int Shift        (luminance shift parameter, i.e. deltag)
  189. Output par: none
  190. Function  : Takes a 3d image and scale it (*) with Mul and the shifts it with (+)
  191.             Shift. The order of the * and + is important!
  192. ***************************************|***************************************/
  193.  
  194.  void T_CScaleAndLShift(BitMap *SrcImg,float Scale,int Shift)
  195.   {
  196.    register unsigned int x=SrcImg->XSize,y;
  197.    register int Val;
  198.    
  199.    while(x--)      
  200.     {
  201.      y=SrcImg->YSize;
  202.      while(y--)        
  203.       {
  204.          Val = (int)(SrcImg->Map[x][y]*Scale+0.5)+Shift;
  205.          if (Val>255) Val=255; /* limit the output */
  206.          if (Val<0)   Val=0;   /* to the range 0-255 */
  207.          SrcImg->Map[x][y]=Val;
  208.       }
  209.     }
  210.   }
  211.  
  212. /**************************************|****************************************
  213. Routine   : T_AbsorbGrey3D
  214. Input  par: BitMap3D *SrcImg  (3d image to be absorbed)
  215.             unsigned char Par (absorbtion parameter)
  216. Output par: none
  217. Function  : Converts a 3d image to a homogeneous block of level Par.
  218. ***************************************|***************************************/
  219.  
  220.  void T_AbsorbGrey(BitMap *SrcImg, unsigned char Par)
  221.   {
  222.    register unsigned int x,y;
  223.    const unsigned int Sizex=SrcImg->XSize;
  224.    const unsigned int Sizey=SrcImg->YSize;
  225.    
  226.    for(x=0;x<Sizex;x++)      
  227.    for(y=0;y<Sizey;y++)
  228.    SrcImg->Map[x][y]=Par;
  229.   }
  230.  
  231. /**************************************|****************************************
  232. Routine   : Sample3D
  233. Input  par: BitMap3D *SrcImg (image to sample from)
  234.             BitMap3D *DstImg (destination image)
  235.             int XPos,int YPos,int ZPos (the position in the source image)
  236. Output par: none
  237. Function  : Takes a 3d image 
  238. ***************************************|***************************************/
  239.  
  240.  void Sample(BitMap *SrcImg,BitMap *DstImg,int XPos,int YPos)
  241.   {
  242.    register unsigned int x,y,i,j;
  243.    register unsigned int Sum;
  244.    const unsigned int Sizex=DstImg->XSize<<1;
  245.    const unsigned int Sizey=DstImg->YSize<<1;
  246.    
  247.    for(x=0;x<Sizex;x+=2)      
  248.     {
  249.      for(y=0;y<Sizey;y+=2)        
  250.       {
  251.        Sum=0;
  252.        for(i=0;i<2;i++)          
  253.        for(j=0;j<2;j++)
  254.        Sum+=SrcImg->Map[XPos+x+i][YPos+y+j];
  255.        
  256.        DstImg->Map[x>>1][y>>1]=Sum>>2;
  257.       }
  258.     }
  259.   }
  260.  
  261. /**************************************|****************************************
  262. Routine   : *Expand23D
  263. Input  par: BitMap3D *SrcImg (image to be expanded)
  264. Output par: BitMap3D * (pointer to expanded image)
  265. Function  : Takes an image and expand it with a factor two.
  266. ***************************************|***************************************/
  267.  
  268.  BitMap *Expand2(BitMap *SrcImg)
  269.   {
  270.    BitMap *DstImg=GimmeABitMap((SrcImg->XSize)<<1,(SrcImg->YSize)<<1,
  271.                          SrcImg->ImgType);
  272.    register unsigned int x,y;
  273.    const unsigned int Sizex=DstImg->XSize;
  274.    const unsigned int Sizey=DstImg->YSize;
  275.  
  276.    for(x=0;x<Sizex;x++)    
  277.    for(y=0;y<Sizey;y++) 
  278.    DstImg->Map[x][y]=SrcImg->Map[x>>1][y>>1];
  279.    
  280.    FreeMeABitMap(SrcImg);
  281.    return DstImg;
  282.   }
  283.  
  284. /**************************************|****************************************
  285. Routine   : PSNR3D
  286. Input  par: BitMap3D *ImgA,BitMap3D *ImgB (images to be comparred)
  287. Output par: float (PSNR value)
  288. Function  : Calculates the PSNR value of two 3d images.
  289. ***************************************|***************************************/
  290.  
  291.  float PSNR(BitMap *ImgA,BitMap *ImgB)
  292.   {
  293.    float ret;
  294.    unsigned long mse=0;
  295.    
  296.    mse=dl2(ImgA,0,0,ImgB);
  297.    ret=10.0*log10((float)(255*255)/(float)mse*(float)(ImgB->XSize*ImgB->YSize));
  298.    return ret;
  299.   }
  300.  
  301. /**************************************|****************************************
  302. Routine   : dl23D
  303. Input  par: BitMap3D *ImgA (first image)
  304.             int AXPos,int AYPos, int AZPos (postion in first image)
  305.             BitMap3D *ImgB (second image)
  306. Output par: unsigned long
  307. Function  : Calculates the dl2 distance between two images.
  308.             Notice: no division with volume!
  309. ***************************************|***************************************/
  310.  
  311.  unsigned long dl2(BitMap *ImgA,int AXPos,int AYPos,BitMap *ImgB)
  312.   {
  313.    register unsigned int x,y;
  314.    register unsigned long Distortion=0;
  315.    register int tmp;
  316.    const unsigned int Sizex=ImgB->XSize;
  317.    const unsigned int Sizey=ImgB->YSize;
  318.  
  319.    for(x=0;x<Sizex;x++)    
  320.    for(y=0;y<Sizey;y++)      
  321.     {
  322.      tmp=ImgA->Map[AXPos+x][AYPos+y]-ImgB->Map[x][y];
  323.      Distortion +=tmp*tmp;
  324.     }
  325.    /* no div with volume ! */
  326.    
  327.    return Distortion;
  328.   }
  329.  
  330. /**************************************|****************************************
  331. Routine   : Isometri3D
  332. Input  par: BitMap3D *SrcImg (bitmap to be rotated)
  333.             BitMap3D *DstImg (output from manipulation)
  334.             int type (the isometri type: 1-8)
  335. Output par: none.
  336. Function  : Isometric transformaition of a 3d image. 
  337. ***************************************|***************************************/
  338.  
  339.  void Isometri(BitMap *SrcImg,BitMap *DstImg, int type)
  340.   {
  341.    register unsigned int y,x;
  342.    const unsigned int Sizex=SrcImg->XSize;
  343.    const unsigned int Sizey=SrcImg->YSize;
  344.  
  345.    switch(type)    
  346.     {
  347.      case 1:
  348.      for(x=0;x<Sizex;x++)      
  349.      for(y=0;y<Sizey;y++)
  350.      DstImg->Map[x][y]=SrcImg->Map[x][y];
  351.      break;
  352.      case 2: 
  353.      for(x=0;x<Sizex;x++)      
  354.      for(y=0;y<Sizey;y++)
  355.      DstImg->Map[x][y]=SrcImg->Map[x][Sizey-1-y];
  356.      break;
  357.      case 3: 
  358.      for(x=0;x<Sizex;x++)      
  359.      for(y=0;y<Sizey;y++)
  360.      DstImg->Map[x][y]=SrcImg->Map[Sizex-1-x][y];
  361.      break;
  362.      case 4: 
  363.      for(x=0;x<Sizex;x++)      
  364.      for(y=0;y<Sizey;y++)
  365.      DstImg->Map[x][y]=SrcImg->Map[y][x];
  366.      break;
  367.      case 5: 
  368.      for(x=0;x<Sizex;x++)      
  369.      for(y=0;y<Sizey;y++)
  370.      DstImg->Map[x][y]=SrcImg->Map[Sizex-1-y][Sizey-1-x];
  371.      break;
  372.      case 6: 
  373.      for(x=0;x<Sizex;x++)      
  374.      for(y=0;y<Sizey;y++)
  375.      DstImg->Map[x][y]=SrcImg->Map[y][Sizey-1-x];
  376.      break;
  377.      case 7: 
  378.      for(x=0;x<Sizex;x++)      
  379.      for(y=0;y<Sizey;y++)
  380.      DstImg->Map[x][y]=SrcImg->Map[Sizex-1-x][Sizey-1-y];
  381.      break;
  382.      case 8:
  383.      for(x=0;x<Sizex;x++)      
  384.      for(y=0;y<Sizey;y++)
  385.      DstImg->Map[x][y]=SrcImg->Map[Sizex-1-y][x];
  386.      break;
  387.     }
  388.   }
  389.  
  390. /**************************************|****************************************
  391. Routine   : IsoAnddl23D
  392. Input  par: BitMap3D *ImgA (image to be transformed)
  393.             int AXPos, int AYPos, int AZPos (position in original image)
  394.             BitMap3D *ImgB (image to compare to)
  395.             int Size       (size (side length) of comparation volumen)
  396.             int type       (type of isometrie)
  397. Output par: unsigned long  (dl2 distortion)
  398. Function  : A combined version of dl2 and isometri. It takes an image and calcs
  399.             the dl23d distortion to another image with repect to a given 
  400.             isometri tranfromation. This is done to reduce encoding time!
  401.             Notice: no division with volume!
  402. ***************************************|***************************************/
  403.  
  404.  unsigned long IsoAnddl2(BitMap *ImgA, int AXPos, int AYPos,
  405.                          BitMap *ImgB, int Size, int type)
  406.   {
  407.    register int x,y;
  408.    register unsigned long Distortion=0;
  409.    register int tmp;
  410.    const unsigned int Sizex=ImgB->XSize;
  411.    const unsigned int Sizey=ImgB->YSize;
  412.  
  413.    x=Sizex;
  414.    switch(type)    
  415.     {
  416.      case 1:
  417.      while(x--)
  418.       {
  419.        y=Sizey;
  420.        while(y--)
  421.         {
  422.            tmp=ImgA->Map[AXPos+x][AYPos+y]-ImgB->Map[x][y];
  423.            Distortion+=tmp*tmp;
  424.         }
  425.       }
  426.      break;
  427.      case 2:
  428.      while(x--)      
  429.       {
  430.        y=Sizey;
  431.        while(y--)
  432.         {
  433.            tmp=ImgA->Map[AXPos+x][AYPos+y]-ImgB->Map[x][Sizey-1-y];
  434.            Distortion+=tmp*tmp;
  435.         }
  436.       }
  437.      break;
  438.      case 3:
  439.      while(x--)      
  440.       {
  441.        y=Sizey;
  442.        while(y--)        
  443.         {
  444.            tmp=ImgA->Map[AXPos+x][AYPos+y]-ImgB->Map[Sizex-1-x][y];
  445.            Distortion+=tmp*tmp;
  446.         }
  447.       }
  448.      
  449.      break;
  450.      case 4:
  451.      while(x--)      
  452.       {
  453.        y=Sizey;
  454.        while(y--)        
  455.         {
  456.            tmp=ImgA->Map[AXPos+x][AYPos+y]-ImgB->Map[y][x];
  457.            Distortion+=tmp*tmp;
  458.         }
  459.       }
  460.      break;
  461.      case 5:
  462.      while(x--)      
  463.       {
  464.        y=Sizey;
  465.        while(y--)        
  466.         {
  467.            tmp=ImgA->Map[AXPos+x][AYPos+y]-ImgB->Map[Sizex-1-y][Sizey-1-x];
  468.            Distortion+=tmp*tmp;
  469.         }
  470.       }
  471.      break;
  472.      case 6:
  473.      while(x--)      
  474.       {
  475.        y=Sizey;
  476.        while(y--)        
  477.         {
  478.            tmp=ImgA->Map[AXPos+x][AYPos+y]-ImgB->Map[y][Sizey-1-x];
  479.            Distortion+=tmp*tmp;
  480.         }
  481.       }
  482.      break;
  483.      case 7:
  484.      while(x--)      
  485.       {
  486.        y=Sizey;
  487.        while(y--)        
  488.         {
  489.            tmp=ImgA->Map[AXPos+x][AYPos+y]-ImgB->Map[Sizex-1-x][Sizey-1-y];
  490.            Distortion+=tmp*tmp;
  491.         }
  492.       }
  493.      break;
  494.      case 8:
  495.      while(x--)      
  496.       {
  497.        y=Sizey;
  498.        while(y--)        
  499.         {
  500.            tmp=ImgA->Map[AXPos+x][AYPos+y]-ImgB->Map[Sizex-1-y][x];
  501.            Distortion+=tmp*tmp;
  502.         }
  503.       }
  504.      break;
  505.     }
  506.    
  507.    return Distortion; /* notice no div with Size*Size*Size! */
  508.   }
  509.  
  510. /**************************************|****************************************
  511. Routine   : MakeRange
  512. Input  par: float p (float to be conveted)
  513.             Parameter *pa (pointer to the parameters)
  514. Output par: unsigned char (output from the quantization)
  515. Function  : Converts a float to an unsigned char according to the range given
  516.             in the parameters. The float is quantizied asymetric.
  517.             Range:  {pa->AMin,pa->AMax} 
  518.             Bits used: pa->ABits
  519. ***************************************|***************************************/
  520.  
  521.  unsigned char MakeRange(float p,Parameter *pa) /* asymetric quant */
  522.   {
  523.    if (p>pa->AMax) p=pa->AMax;
  524.    if (p<pa->AMin) p=pa->AMin;
  525.    return (unsigned char)((p-pa->AMin)/(pa->AMax-pa->AMin)*(float)((1<<pa->ABits)-1)+0.5);
  526.   }
  527.  
  528. /**************************************|****************************************
  529. Routine   : MakeFloat
  530. Input  par: unsigned char conv (bitarray to be converted)
  531.             Parameter *pa (poiter to parameters)
  532. Output par: float (converted integer)
  533. Function  : Converts an unsiged char (or bitarray) to a float. See MakeRange.
  534. ***************************************|***************************************/
  535.  
  536.  
  537.  float MakeFloat(unsigned char conv,Parameter *pa)
  538.   {
  539.    return (float)((conv)*(pa->AMax-pa->AMin)/(float)((1<<pa->ABits)-1)+pa->AMin);
  540.   }
  541.